// 本地存储管理工具
class LocalStorage {
    constructor() {
        this.userKey = 'memo_users'
        this.currentUserKey = 'memo_current_user'
        this.memoKey = 'memo_data'
        this.tokenKey = 'memo_token'
        
        // 初始化存储
        this.initStorage()
    }
    
    // 初始化存储
    initStorage() {
        if (!uni.getStorageSync(this.userKey)) {
            uni.setStorageSync(this.userKey, [])
        }
        if (!uni.getStorageSync(this.memoKey)) {
            uni.setStorageSync(this.memoKey, [])
        }
        
        // 初始化超级管理员账号
        this.initSuperAdmin()
    }
    
    // 初始化超级管理员账号
    initSuperAdmin() {
        const users = uni.getStorageSync(this.userKey) || []
        
        // 检查是否已存在超级管理员
        const adminExists = users.some(user => user.username === 'admin' && user.isAdmin === true)
        
        if (!adminExists) {
            // 检查管理员手机号是否被普通用户占用
            const phoneConflictUser = users.find(user => user.phone === '18290362536' && !user.isAdmin)
            
            let adminPhone = '18290362536'
            
            // 如果手机号被占用，使用备用手机号
            if (phoneConflictUser) {
                adminPhone = '19999999999' // 备用管理员手机号
                console.warn('管理员默认手机号被占用，使用备用手机号:', adminPhone)
            }
            
            const adminUser = {
                id: 999999, // 固定ID
                username: 'admin',
                name: '超级管理员',
                phone: adminPhone,
                password: '<1314520hf>',
                nickname: '超级管理员',
                avatar: '',
                isAdmin: true,
                createTime: new Date().toISOString(),
                updateTime: new Date().toISOString()
            }
            
            users.unshift(adminUser) // 添加到数组开头
            uni.setStorageSync(this.userKey, users)
            
            // 为管理员创建特殊的示例备忘录
            this.createAdminSampleMemos(adminUser.id)
        } else {
            // 如果管理员已存在，检查是否需要创建初始备忘录（仅在没有备忘录时创建）
            const adminUser = users.find(user => user.username === 'admin' && user.isAdmin === true)
            const allMemos = uni.getStorageSync(this.memoKey) || []
            const adminMemos = allMemos.filter(memo => memo.userId === adminUser.id)
            
            // 只有当管理员没有任何备忘录时才创建示例备忘录
            if (adminMemos.length === 0) {
                this.createAdminSampleMemos(adminUser.id)
            }
        }
    }
    
    // ========== 用户管理 ==========
    
    // 用户注册
    register(userData) {
        const users = uni.getStorageSync(this.userKey) || []
        
        // 检查是否使用了管理员专用的用户名
        if (userData.username === 'admin') {
            return {
                success: false,
                message: '该用户名为系统保留，请使用其他用户名'
            }
        }
        
        // 检查是否使用了管理员专用的手机号
        if (userData.phone === '18290362536' || userData.phone === '19999999999') {
            return {
                success: false,
                message: '该手机号为系统保留，请使用其他手机号'
            }
        }
        
        // 检查手机号是否已存在
        const existUser = users.find(user => user.phone === userData.phone)
        if (existUser) {
            return {
                success: false,
                message: '手机号已存在'
            }
        }
        
        // 检查用户名是否已存在
        const existUsername = users.find(user => user.username === userData.username)
        if (existUsername) {
            return {
                success: false,
                message: '用户名已存在'
            }
        }
        
        // 创建新用户
        const newUser = {
            id: Date.now(),
            username: userData.username,
            name: userData.name,
            phone: userData.phone,
            password: userData.password,
            nickname: userData.name || `用户${userData.phone.substr(-4)}`,
            avatar: '',
            isAdmin: false, // 普通用户默认不是管理员
            createTime: new Date().toISOString(),
            updateTime: new Date().toISOString()
        }
        
        users.push(newUser)
        uni.setStorageSync(this.userKey, users)
        
        // 自动登录
        const token = this.generateToken(newUser.id)
        this.setCurrentUser(newUser, token)
        
        // 为新用户创建示例备忘录
        this.createSampleMemos(newUser.id)
        
        return {
            success: true,
            message: '注册成功',
            data: {
                userId: newUser.id,
                token: token,
                userInfo: this.getUserInfo(newUser)
            }
        }
    }
    
    // 用户登录（支持手机号或用户名）
    login(loginId, password) {
        const users = uni.getStorageSync(this.userKey) || []
        const user = users.find(u => 
            (u.phone === loginId || u.username === loginId) && u.password === password
        )
        
        if (!user) {
            return {
                success: false,
                message: '账号或密码错误'
            }
        }
        
        const token = this.generateToken(user.id)
        this.setCurrentUser(user, token)
        
        return {
            success: true,
            message: '登录成功',
            data: {
                userId: user.id,
                token: token,
                userInfo: this.getUserInfo(user)
            }
        }
    }
    
    // 生成Token
    generateToken(userId) {
        return `token_${userId}_${Date.now()}`
    }
    
    // 设置当前用户
    setCurrentUser(user, token) {
        uni.setStorageSync(this.currentUserKey, user)
        uni.setStorageSync(this.tokenKey, token)
    }
    
    // 获取当前用户
    getCurrentUser() {
        return uni.getStorageSync(this.currentUserKey)
    }
    
    // 获取Token
    getToken() {
        return uni.getStorageSync(this.tokenKey)
    }
    
    // 检查是否已登录
    isLoggedIn() {
        const user = this.getCurrentUser()
        const token = this.getToken()
        return !!(user && token)
    }
    
    // 退出登录
    logout() {
        uni.removeStorageSync(this.currentUserKey)
        uni.removeStorageSync(this.tokenKey)
    }
    
    // 获取用户信息（去除敏感信息）
    getUserInfo(user) {
        const { password, ...userInfo } = user
        return userInfo
    }
    
    // 更新用户信息
    updateUserInfo(updateData) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const users = uni.getStorageSync(this.userKey) || []
        const userIndex = users.findIndex(u => u.id === currentUser.id)
        
        if (userIndex === -1) {
            return { success: false, message: '用户不存在' }
        }
        
        // 更新用户信息
        const updatedUser = {
            ...users[userIndex],
            ...updateData,
            updateTime: new Date().toISOString()
        }
        
        users[userIndex] = updatedUser
        uni.setStorageSync(this.userKey, users)
        
        // 更新当前用户缓存
        uni.setStorageSync(this.currentUserKey, updatedUser)
        
        return {
            success: true,
            message: '更新成功',
            data: this.getUserInfo(updatedUser)
        }
    }
    
    // ========== 备忘录管理 ==========
    
    // 获取备忘录列表
    getMemoList(options = {}) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { 
                success: true, 
                data: {
                    list: [],
                    total: 0,
                    page: 1,
                    pageSize: 20,
                    hasMore: false
                }
            }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        let userMemos = allMemos.filter(memo => memo.userId === currentUser.id && memo.status === 1)
        
        // 分类筛选
        if (options.category) {
            userMemos = userMemos.filter(memo => memo.category === options.category)
        }
        
        // 关键词搜索
        if (options.keyword) {
            const keyword = options.keyword.toLowerCase()
            userMemos = userMemos.filter(memo => 
                memo.title.toLowerCase().includes(keyword) || 
                memo.content.toLowerCase().includes(keyword)
            )
        }
        
        // 按创建时间倒序排列
        userMemos.sort((a, b) => new Date(b.createTime) - new Date(a.createTime))
        
        // 分页处理
        const page = options.page || 1
        const pageSize = options.pageSize || 20
        const startIndex = (page - 1) * pageSize
        const endIndex = startIndex + pageSize
        const paginatedMemos = userMemos.slice(startIndex, endIndex)
        
        return {
            success: true,
            data: {
                list: paginatedMemos,
                total: userMemos.length,
                page: page,
                pageSize: pageSize,
                hasMore: endIndex < userMemos.length
            }
        }
    }
    
    // 获取备忘录详情
    getMemoDetail(memoId) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const memo = allMemos.find(m => m.id == memoId && m.userId === currentUser.id && m.status === 1)
        
        if (!memo) {
            return { success: false, message: '备忘录不存在' }
        }
        
        return {
            success: true,
            data: memo
        }
    }
    
    // 创建备忘录
    createMemo(memoData) {
        const currentUser = this.getCurrentUser()
        const userId = currentUser ? currentUser.id : 0  // 未登录用户使用ID 0
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const newMemo = {
            id: Date.now(),
            userId: userId,
            title: memoData.title,
            content: memoData.content,
            category: memoData.category || 'general',
            important: memoData.important || false,
            status: 1, // 1:正常 0:删除
            createTime: new Date().toISOString(),
            updateTime: new Date().toISOString()
        }
        
        allMemos.push(newMemo)
        uni.setStorageSync(this.memoKey, allMemos)
        
        return {
            success: true,
            message: '创建成功',
            data: newMemo
        }
    }
    
    // 更新备忘录
    updateMemo(memoId, updateData) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const memoIndex = allMemos.findIndex(m => m.id == memoId && m.userId === currentUser.id)
        
        if (memoIndex === -1) {
            return { success: false, message: '备忘录不存在' }
        }
        
        // 更新备忘录
        const updatedMemo = {
            ...allMemos[memoIndex],
            ...updateData,
            updateTime: new Date().toISOString()
        }
        
        allMemos[memoIndex] = updatedMemo
        uni.setStorageSync(this.memoKey, allMemos)
        
        return {
            success: true,
            message: '更新成功',
            data: updatedMemo
        }
    }
    
    // 删除备忘录
    deleteMemo(memoId) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const memoIndex = allMemos.findIndex(m => m.id == memoId && m.userId === currentUser.id)
        
        if (memoIndex === -1) {
            return { success: false, message: '备忘录不存在' }
        }
        
        // 软删除
        allMemos[memoIndex].status = 0
        allMemos[memoIndex].updateTime = new Date().toISOString()
        
        uni.setStorageSync(this.memoKey, allMemos)
        
        return {
            success: true,
            message: '删除成功'
        }
    }
    
    // 批量删除备忘录
    batchDeleteMemo(memoIds) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        let deletedCount = 0
        
        memoIds.forEach(memoId => {
            const memoIndex = allMemos.findIndex(m => m.id == memoId && m.userId === currentUser.id)
            if (memoIndex !== -1) {
                allMemos[memoIndex].status = 0
                allMemos[memoIndex].updateTime = new Date().toISOString()
                deletedCount++
            }
        })
        
        uni.setStorageSync(this.memoKey, allMemos)
        
        return {
            success: true,
            message: '批量删除成功',
            data: { deletedCount }
        }
    }
    
    // ========== 统计功能 ==========
    
    // 获取统计数据
    getStats() {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { 
                success: true, 
                data: {
                    totalMemos: 0,
                    todayMemos: 0,
                    importantMemos: 0,
                    categoryStats: []
                }
            }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const userMemos = allMemos.filter(memo => memo.userId === currentUser.id && memo.status === 1)
        
        // 分类统计
        const categoryStats = {}
        userMemos.forEach(memo => {
            categoryStats[memo.category] = (categoryStats[memo.category] || 0) + 1
        })
        
        // 今日备忘录
        const today = new Date().toDateString()
        const todayMemos = userMemos.filter(memo => 
            new Date(memo.createTime).toDateString() === today
        )
        
        // 重要备忘录
        const importantMemos = userMemos.filter(memo => memo.important)
        
        return {
            success: true,
            data: {
                totalMemos: userMemos.length,
                todayMemos: todayMemos.length,
                importantMemos: importantMemos.length,
                categoryStats: Object.entries(categoryStats).map(([category, count]) => ({
                    category,
                    count,
                    percentage: ((count / userMemos.length) * 100).toFixed(1)
                }))
            }
        }
    }
    
    // ========== 数据导入导出 ==========
    
    // 导出用户数据
    exportUserData() {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const userMemos = allMemos.filter(memo => memo.userId === currentUser.id)
        
        const exportData = {
            userInfo: this.getUserInfo(currentUser),
            memos: userMemos,
            exportTime: new Date().toISOString()
        }
        
        return {
            success: true,
            data: exportData
        }
    }
    
    // 清空用户数据（慎用）
    clearUserData() {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        // 删除用户的所有备忘录
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const filteredMemos = allMemos.filter(memo => memo.userId !== currentUser.id)
        uni.setStorageSync(this.memoKey, filteredMemos)
        
        return {
            success: true,
            message: '数据清空成功'
        }
    }
    
    // 为新用户创建示例备忘录
    createSampleMemos(userId) {
        const sampleMemos = [
            {
                id: Date.now() + 1,
                userId: userId,
                title: '欢迎使用小何备忘录',
                content: `<p>欢迎使用小何备忘录应用！</p>
                
                <h3>🎉 主要功能</h3>
                <p>• 创建和编辑备忘录</p>
                <p>• 分类管理（工作、生活、学习等）</p>
                <p>• 重要标记功能</p>
                <p>• 本地数据存储</p>
                
                <h3>💡 使用技巧</h3>
                <p>• 点击右下角的"+"按钮创建新备忘录</p>
                <p>• 在编辑页面可以选择不同的分类</p>
                <p>• 支持富文本内容</p>
                
                <blockquote>💭 这是一个示例备忘录，您可以随时删除或编辑它。</blockquote>`,
                category: 'general',
                important: false,
                status: 1,
                createTime: new Date().toISOString(),
                updateTime: new Date().toISOString()
            },
            {
                id: Date.now() + 2,
                userId: userId,
                title: '工作效率提升指南',
                content: `<p>提高工作效率是每个人都关心的话题。以下是一些实用的建议：</p>
                
                <h3>📝 时间管理</h3>
                <p>• 使用番茄工作法，25分钟专注工作，5分钟休息</p>
                <p>• 制定每日任务清单，按优先级排序</p>
                <p>• 避免多任务处理，一次只做一件事</p>
                
                <h3>🎯 目标设定</h3>
                <p>• 设定SMART目标（具体、可衡量、可达成、相关性、时限性）</p>
                <p>• 将大目标分解为小步骤</p>
                <p>• 定期回顾和调整目标</p>
                
                <blockquote>💡 记住：效率不是做更多的事，而是做对的事。</blockquote>`,
                category: 'work',
                important: true,
                status: 1,
                createTime: new Date(Date.now() - 86400000).toISOString(), // 昨天
                updateTime: new Date(Date.now() - 86400000).toISOString()
            },
            {
                id: Date.now() + 3,
                userId: userId,
                title: '健康生活小贴士',
                content: `<p>保持健康的生活方式对每个人都很重要。</p>
                
                <h3>🏃 运动习惯</h3>
                <p>• 每天至少30分钟的有氧运动</p>
                <p>• 每周2-3次力量训练</p>
                <p>• 多走楼梯，少坐电梯</p>
                
                <h3>🥗 饮食建议</h3>
                <p>• 多吃蔬菜水果</p>
                <p>• 控制糖分和盐分摄入</p>
                <p>• 保持充足的水分</p>
                
                <h3>😴 作息规律</h3>
                <p>• 每天7-8小时睡眠</p>
                <p>• 规律的作息时间</p>
                <p>• 睡前1小时避免使用电子设备</p>`,
                category: 'health',
                important: false,
                status: 1,
                createTime: new Date(Date.now() - 172800000).toISOString(), // 前天
                updateTime: new Date(Date.now() - 172800000).toISOString()
            }
        ];
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        allMemos.push(...sampleMemos)
        uni.setStorageSync(this.memoKey, allMemos)
    }
    
    // 为管理员创建特殊的示例备忘录
    createAdminSampleMemos(userId) {
        const adminMemos = [
            {
                id: Date.now() + 100,
                userId: userId,
                title: '欢迎使用小何备忘录！',
                content: `<p><strong>🎉 欢迎来到小何备忘录本地存储版！</strong></p>
                
                <h3>✨ 产品特色</h3>
                <p>• 📱 跨平台支持：微信小程序、H5浏览器、App</p>
                <p>• 🔒 本地存储：数据完全保存在本地，保护隐私</p>
                <p>• 🎨 多种分类：工作、生活、学习、旅行等8大分类</p>
                <p>• 🔐 安全保护：应用锁、指纹解锁、手势密码</p>
                
                <h3>🚀 快速开始</h3>
                <p>• 点击"+"按钮创建你的第一条备忘录</p>
                <p>• 选择合适的分类让备忘录更有条理</p>
                <p>• 标记重要备忘录，优先显示</p>
                <p>• 使用搜索功能快速找到所需内容</p>
                
                <blockquote>💡 开始记录你的精彩生活吧！</blockquote>`,
                category: 'general',
                important: true,
                status: 1,
                createTime: new Date().toISOString(),
                updateTime: new Date().toISOString()
            },
            {
                id: Date.now() + 101,
                userId: userId,
                title: '产品使用技巧',
                content: `<p><strong>📝 让备忘录更高效的小技巧：</strong></p>
                
                <h3>🏷️ 分类管理</h3>
                <p>• 工作备忘录：会议记录、任务清单、项目进度</p>
                <p>• 生活备忘录：购物清单、家务安排、重要日期</p>
                <p>• 学习备忘录：读书笔记、学习计划、知识要点</p>
                <p>• 旅行备忘录：行程安排、景点推荐、注意事项</p>
                
                <h3>⭐ 重要标记</h3>
                <p>• 对紧急或重要的备忘录添加重要标记</p>
                <p>• 重要备忘录会在列表中优先显示</p>
                
                <h3>🔍 搜索功能</h3>
                <p>• 支持标题和内容的全文搜索</p>
                <p>• 快速定位所需备忘录</p>
                
                <h3>📊 数据管理</h3>
                <p>• 定期导出备份重要数据</p>
                <p>• 及时清理不需要的备忘录</p>
                
                <blockquote>🎯 好的分类习惯让信息管理事半功倍！</blockquote>`,
                category: 'general',
                important: false,
                status: 1,
                createTime: new Date(Date.now() - 60000).toISOString(), // 1分钟前
                updateTime: new Date(Date.now() - 60000).toISOString()
            }
        ];
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        allMemos.push(...adminMemos)
        uni.setStorageSync(this.memoKey, allMemos)
    }
}

// 创建单例实例
const localStorage = new LocalStorage()

export default localStorage 